#include "mscstring.h"


/* 字符串匹配
 * 函数名：char *mscStrStr(char *str1,char *str2)
 * 输入：
 *      str1 目标字符串
 *      str2 源字符串
 *      默认为是字符串比较,不相等返回NULL
 * 返回：str2在str1中的开始位置
 */
char *mscStrStr(char *str1,char *str2)
{
    char *p1 = str1,*p2 = str2;
    uint32_t str1len = 0,str2len = 0;

    while(*p1 ++)
    {
        str1len ++;
    }
    while(*p2 ++)
    {
        str2len ++;
    }

    p1 = str1;
    p2 = str2;

    if((*p2 == '^') || (*p2 == '$') || (*p2 == '*'))
    {  
        str2len -= 1;
    }
    if(str2len > str1len)
        return NULL;
    if(*p2 == '^')//匹配开始
    {
        p2 ++;
        while(*p2)
        {
            if(!*p1) return NULL;
            if(*p1++ != *p2++)
                return NULL;
        }
        return (p1 - str2len);
    }
    else if(*p2 == '$')//匹配末尾
    {
        p2 ++;
        p1 += (str1len - str2len);
        while(*p2)
        {
            if(!*p1) return NULL;
            if(*p1++ != *p2++)
                return NULL;
        }
        return (p1 - str2len);
    }
    else if(*p2 == '*')//任意匹配
    {
        p2 ++;
        while(*p2)
        {
            if(!*p1) return NULL;
            if(*p1++ != *p2++)
            {
                p2 = str2 + 1;
                continue;
            }
        }
        return (p1 - str2len);
    }
    else
    {
        if(str2len != str1len)
            return NULL;
        while(*p2)
        {
            if(!*p1) return NULL;
            if(*p1++ != *p2++)
                return NULL;
        }
        return (p1);
    }
    
    return NULL;
}

/* 拷贝两个数组
 * 函数名：void mscCpy2Array(uint8_t *array1,uint8_t *array2,uint32_t len)
 * 输入：
 *      array1  数组1指针
 * 		array2  数组2指针
 * 		len     拷贝长度
 * 返回：
 */
void mscCpy2Array(uint8_t *array1,uint8_t *array2,uint32_t len)
{
    for(uint32_t i = 0;i < len;i ++)
    {
        *(array1 + i) = *(array2 + i);
    }
}

/* 大写转小写
 * 函数名：char mscLetterUpper(char ch)
 * 输入：转换对象
 * 返回：转换后值
 */
char mscLetterUpper(char ch)
{
    if('a' <= ch && ch <= 'z')
        ch -= 32;
    return ch;
}

/* 小写转大写
 * 函数名：char mscUpperLetter(char ch)
 * 输入：转换对象
 * 返回：转换后值
 */
char mscUpperLetter(char ch)
{
    if('A' <= ch && ch <= 'Z')
        ch += 32;
    return ch;
}

/* 比较两个数组 
 * 函数名：int mscCmp2Array(uint8_t *array1,uint8_t *array2,uint32_t len)
 * 输入：
 *      array1  数组1指针
 * 		array2  数组2指针
 * 		len     比较长度
 * 返回：一致返回1 不一致返回0
 */
int mscCmp2Array(uint8_t *array1,uint8_t *array2,uint32_t len)
{
    for(uint32_t i = 0;i < len;i ++)
    {
        if(*(array1 + i) != *(array2 + i))
            return 0;
    }
    return 1;
}

/* 比较两个数组 ,字母不区分大小写
 * 函数名：int mscCmpi2Array(uint8_t *array1,uint8_t *array2,uint32_t len)
 * 输入：
 *      array1  数组1指针
 * 		array2  数组2指针
 * 		len     比较长度
 * 返回：一致返回1 不一致返回0
 */
int mscCmpi2Array(uint8_t *array1,uint8_t *array2,uint32_t len)
{
    for(uint8_t i = 0;i < len;i ++)
    {
        if(mscLetterUpper((char)*(array1 + 1)) != mscLetterUpper((char)*(array2 + 1)))
            return 0;
    }
    return 1;
}

/* 10进制字符串转10进制数
 * 函数名：int mscAtoi(char* pstr)
 * 输入：字符串
 * 返回：10进制数
 */
int mscAtoi(char *pstr)
{
    int Ret_Integer = 0;
    int Integer_sign = 1;
    if(pstr == NULL)
    {
        return 0;
    }
    while(*pstr == ' ')
    {
        pstr++;
    }
    if(*pstr == '-')
    {
        Integer_sign = -1;
    }
    if(*pstr == '-' || *pstr == '+')
    {
        pstr++;
    }
    while(*pstr >= '0' && *pstr <= '9')
    {
        Ret_Integer = Ret_Integer * 10 + *pstr - '0';
        pstr++;
    }
    Ret_Integer = Integer_sign * Ret_Integer;

    return Ret_Integer;
}

/* 进制转换
 * 函数名：int mscInt(char *data)
 * 输入：字符串，0x开头为16进制字符串，其它认为是10进制字符串
 * 返回：10进制数
 */
int mscInt(char *data)
{
    int i = 0,j = 0;
    if((*(data) == '0') && (*(data + 1) == 'X' || *(data + 1) == 'x'))
    {
        data += 2;
        while(*data)
        {
            if(*data <= '9')
                j = *data - '0';
            else if(*data <= 'F')
                j = *data - 'A' + 10;
            else if(*data <= 'f')
                j = *data - 'a' + 10;

            i = i * 16 + j;
            data ++;
        }
    }
    else
    {
        return mscAtoi(data);
    }
    return i;
}

/* 进制转换
 * 函数名：int mscMintl(char *data,int start,int end,int b)
 * 输入：字符串，起始索引，终止索引，字符串进制
 * 返回：10进制数
 */
int mscMintl(char *data,int start,int end,int b)
{
    char buf[13] = {0,'X',0,0,0,0,0,0,0,0,0,0,0};
    int i = 0;
    if((end - start) > 10)
        return 0;
    for(i = 0;i < (end - start);i ++)
    {
        if(b == 16)
            buf[2 + i] = data[start + i];
        else if(b == 10)
            buf[i] = data[start + i];
    }
    buf[i] = 0;
    return mscInt(buf);
}

/* 整数转字符串
 * 函数名：char *mscItoa(char *buf,int d,int b)
 * 输入：存储缓冲,整数,进制
 * 返回：字符串指针
 */
char *mscItoa(char *buf,int d,int b)
{
	char *s;
	int t, neg = 0;
	unsigned int u = d,ul = 0;

	if((b == 10) && (d < 0)) 
    {
		neg = 1;
		u = -d;
	}
    do
    {
        ul ++;
    }while(u /= 10);

	s = buf + ul;
	*s = '\0';

    u = d;
    if(neg)
    {
        u = (d < 0) ? (-d) : d;
    }

	while(u)
    {
		t = u % b;
		if( t >= 10 )
			t += 'A' - '0' - 10;
		*--s = t + '0';
		u /= b;
	}
    if(neg)
    {
        *--s = '-';
    }
    else if(b == 16)
    {
        *--s = 'x';
        *--s = '0';
    }

    return s;
}


/* 10进制字符串转10进制数,浮点型
 * 函数名：double mscAtof(char* pstr)
 * 输入：字符串
 * 返回：10进制数,浮点型
 */
double mscAtof(char *pstr)
{
    double d = 0,p = 0;
    char *point = NULL;

    point = mscStrStr(pstr,"*.");
    d = mscMintl(pstr,0,(point - pstr),10);
    if(point != NULL)
    {
        p = mscAtoi(++ point);
        while(*point ++)
        {
            p /= 10;
        }
    }
   
    if(d < 0)
        d -= p;
    else
        d += p;

    return d;
}

/* 浮点数转字符串
 * 函数名：char *mscFtoa(char *buf,double d,int width)
 * 输入：存储缓冲,浮点数,保留小数位数
 * 返回：字符串指针
 * 注意：因为用一个全局缓冲,故不可同时进栈
 */
char *mscFtoa(char *buf,double d,int width)
{
    unsigned int z = (unsigned int)d,zl = 0,i = 0,neg = 0;
    double p = 0;
    if(d < 0)
    {    
        neg = 1;
        z = (unsigned int)(-d);
    }
    do
    {
        zl ++;
    }while(z /= 10);

    z = (unsigned int)d;
    p = d - z;
    if(neg)
    {
        buf[0] = '-';
        zl ++;
        z = (unsigned int)(-d);
        p = -(d + z);
    }
    i = zl;
    do
    {
        buf[-- i] = z % 10 + '0';
    }while(z /= 10);
    i = zl;
    buf[i ++] = '.';

    do
    {
        p *= 10;
        buf[i ++] = (unsigned int)p % 10 + '0';
    }while(-- width);

    buf[i] = 0;

    return buf;
}


